home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 8 / QRZ Ham Radio Callsign Database - Volume 8.iso / mac / files / t_sys5 / 92052tar.gz / 920528.tar / main.c < prev    next >
C/C++ Source or Header  |  1992-05-26  |  11KB  |  612 lines
  1. /* @(#) $Header: main.c,v 1.28 92/05/26 10:09:04 deyke Exp $ */
  2.  
  3. /* Main-level NOS program:
  4.  *  initialization
  5.  *  keyboard processing
  6.  *  generic user commands
  7.  *
  8.  * Copyright 1991 Phil Karn, KA9Q
  9.  */
  10. #include <sys/types.h>
  11. #include <stdio.h>
  12. #include <string.h>
  13. #include <time.h>
  14. #if     defined(__TURBOC__) && defined(MSDOS)
  15. #include <io.h>
  16. #include <conio.h>
  17. #endif
  18. #include <unistd.h>
  19. #include "global.h"
  20. #ifdef  ANSIPROTO
  21. #include <stdarg.h>
  22. #endif
  23. #include "mbuf.h"
  24. #include "timer.h"
  25. #include "proc.h"
  26. #include "iface.h"
  27. #include "ip.h"
  28. #include "tcp.h"
  29. #include "udp.h"
  30. #include "ax25.h"
  31. #include "kiss.h"
  32. #include "enet.h"
  33. #include "netrom.h"
  34. #include "ftp.h"
  35. #include "telnet.h"
  36. #include "tty.h"
  37. #include "session.h"
  38. #include "hardware.h"
  39. /* #include "usock.h" */
  40. #include "socket.h"
  41. #include "cmdparse.h"
  42. #include "commands.h"
  43. #include "daemon.h"
  44. #include "devparam.h"
  45. /* #include "domain.h" */
  46. #include "files.h"
  47. #include "main.h"
  48. #include "remote.h"
  49. #include "trace.h"
  50. #include "hpux.h"
  51. #include "netuser.h"
  52. #include "remote_net.h"
  53.  
  54. extern int errno;
  55. extern char *sys_errlist[];
  56.  
  57. extern struct cmds Cmds[],Startcmds[],Stopcmds[],Attab[];
  58.  
  59. #ifndef MSDOS                   /* PC uses F-10 key always */
  60. char Escape = 0x1d;             /* default escape character is ^] */
  61. #endif
  62.  
  63. int Debug;
  64. int Mode;
  65. char Badhost[] = "Unknown host %s\n";
  66. char *Hostname;
  67. char Prompt[] = "%s> ";
  68. char Nospace[] = "No space!!\n";        /* Generic malloc fail message */
  69. struct proc *Cmdpp;
  70. static FILE *Logfp;
  71. time_t StartTime;                       /* time that NOS was started */
  72. int16 Lport = 1024;
  73. static int Verbose;
  74.  
  75. static void process_char __ARGS((int c));
  76.  
  77. int
  78. main(argc,argv)
  79. int argc;
  80. char *argv[];
  81. {
  82.     static char linebuf[BUFSIZ];    /* keep it off the stack */
  83.     FILE *fp;
  84.     struct daemon *tp;
  85.     int c;
  86.  
  87.     time(&StartTime);
  88.  
  89.     Debug = (argc >= 2);
  90.  
  91.     while((c = getopt(argc,argv,"v")) != EOF){
  92.         switch(c){
  93.         case 'v':
  94.             Verbose = 1;
  95.             break;
  96.         }
  97.     }
  98.     kinit();
  99.     ipinit();
  100.     ioinit();
  101.     netrom_initialize();
  102.     remote_net_initialize();
  103.     Cmdpp = mainproc("cmdintrp");
  104.  
  105.     Sessions = (struct session *)callocw(Nsessions,sizeof(struct session));
  106.     printf("\n================ %s ================\n", Version);
  107.     printf("(c) Copyright 1990-1992 by Dieter Deyke, DK5SG / N0PRA\n");
  108.     printf("(c) Copyright 1991 by Phil Karn, KA9Q\n");
  109.     printf("\n");
  110.  
  111.     /* Start background Daemons */
  112.     for(tp=Daemons;;tp++){
  113.         if(tp->name == NULLCHAR)
  114.             break;
  115.         newproc(tp->name,tp->stksize,tp->fp,0,NULLCHAR,NULL,0);
  116.     }
  117.  
  118.     if(optind < argc){
  119.         /* Read startup file named on command line */
  120.         if((fp = fopen(argv[optind],READ_TEXT)) == NULLFILE)
  121.             printf("Can't read config file %s: %s\n",
  122.              argv[optind],sys_errlist[errno]);
  123.     } else {
  124.         fp = fopen(Startup,READ_TEXT);
  125.     }
  126.     if(fp != NULLFILE){
  127.         while(fgets(linebuf,BUFSIZ,fp) != NULLCHAR){
  128.             char intmp[BUFSIZ];
  129.             strcpy(intmp,linebuf);
  130.             if(Verbose)
  131.                 printf("%s",intmp);
  132.             if(cmdparse(Cmds,linebuf,NULL) != 0){
  133.                 printf("input line: %s",intmp);
  134.             }
  135.         }
  136.         fclose(fp);
  137.     }
  138.     cmdmode();
  139.  
  140.     /* Main commutator loop */
  141.     for(;;){
  142.         pwait(NULL);
  143.  
  144.         /* Wait until interrupt, then do it all over again */
  145.         eihalt();
  146.     }
  147. }
  148. /* Enter command mode */
  149. int
  150. cmdmode()
  151. {
  152.     if(Mode != CMD_MODE){
  153.         Mode = CMD_MODE;
  154.         cooked();
  155.         printf(Prompt,Hostname);
  156.     }
  157.     return 0;
  158. }
  159. /* Process keyboard characters */
  160. static void
  161. process_char(c)
  162. int c;
  163. {
  164.  
  165.     char *ttybuf;
  166.     int cnt;
  167.  
  168.     if (c == Escape && Escape != 0) {
  169.         ttydriv('\r', &ttybuf);
  170.         Mode = CONV_MODE;
  171.         cmdmode();
  172.         return;
  173.     }
  174.     if ((cnt = ttydriv(c, &ttybuf)) == 0)
  175.         return;
  176.     switch (Mode) {
  177.     case CMD_MODE:
  178.         cmdparse(Cmds, ttybuf, NULL);
  179.         break;
  180.     case CONV_MODE:
  181.         if (Current->parse != NULLVFP)
  182.             (*Current->parse)(ttybuf, cnt);
  183.         break;
  184.     }
  185.     if (Mode == CMD_MODE)
  186.         printf(Prompt, Hostname);
  187. }
  188. /* Keyboard input process */
  189. void
  190. keyboard(i,v1,v2)
  191. int i;
  192. void *v1;
  193. void *v2;
  194. {
  195.  
  196.     char *p;
  197.     char buf[1024];
  198.     int n;
  199.  
  200.     n = read(0, p = buf, sizeof(buf));
  201.     if (n <= 0) dobye(0, (char **) 0, (void * ) 0);
  202.     while (--n >= 0) {
  203.         process_char(uchar(*p++));
  204.         while (Fkey_ptr && *Fkey_ptr)
  205.             process_char(uchar(*Fkey_ptr++));
  206.     }
  207. }
  208. int
  209. dofkey(argc,argv,p)
  210. int argc;
  211. char *argv[];
  212. void *p;
  213. {
  214.     int n;
  215.  
  216.     n = atoi(argv[1]) - 1;
  217.     if (n < 0 || n >= NUM_FKEY) {
  218.         printf("key# must be 1..%d\n", NUM_FKEY);
  219.         return 1;
  220.     }
  221.     if (Fkey_table[n])
  222.         free(Fkey_table[n]);
  223.     Fkey_table[n] = strdup(argv[2]);
  224.     return 0;
  225. }
  226. /* Standard commands called from main */
  227. int
  228. dodelete(argc,argv,p)
  229. int argc;
  230. char *argv[];
  231. void *p;
  232. {
  233.     int i;
  234.  
  235.     for(i=1;i < argc; i++){
  236.         if(unlink(argv[i]) == -1){
  237.             printf("Can't delete %s: %s\n",
  238.              argv[i],sys_errlist[errno]);
  239.         }
  240.     }
  241.     return 0;
  242. }
  243. int
  244. dorename(argc,argv,p)
  245. int argc;
  246. char *argv[];
  247. void *p;
  248. {
  249.     if(rename(argv[1],argv[2]) == -1)
  250.         printf("Can't rename: %s\n",sys_errlist[errno]);
  251.     return 0;
  252. }
  253. int
  254. doexit(argc,argv,p)
  255. int argc;
  256. char *argv[];
  257. void *p;
  258. {
  259.     time_t StopTime;
  260.     char tbuf[32];
  261.  
  262.     time(&StopTime);
  263.     reset_all();
  264.     shuttrace();
  265.     strcpy(tbuf,ctime(&StopTime));
  266.     rip(tbuf);
  267.     log(NULLTCB,"NOS was stopped at %s", tbuf);
  268.     if(Logfp){
  269.         fclose(Logfp);
  270.         Logfp = NULLFILE;
  271.     }
  272.     iostop();
  273.     exit(0);
  274.     return 0;       /* To satisfy lint */
  275. }
  276. int
  277. dohostname(argc,argv,p)
  278. int argc;
  279. char *argv[];
  280. void *p;
  281. {
  282.     if(argc < 2)
  283.         printf("%s\n",Hostname);
  284.     else {
  285.         struct iface *ifp;
  286.         char *name;
  287.  
  288.         if((ifp = if_lookup(argv[1])) != NULLIF){
  289.             if((name = resolve_a(ifp->addr, FALSE)) == NULLCHAR){
  290.                 printf("Interface address not resolved\n");
  291.                 return 1;
  292.             } else {
  293.                 if(Hostname != NULLCHAR)
  294.                     free(Hostname);
  295.                 Hostname = strdup(name);
  296.  
  297.                 /* remove trailing dot */
  298.                 if ( Hostname[strlen(Hostname)] == '.' ) {
  299.                     Hostname[strlen(Hostname)] = '\0';
  300.                 }
  301.                 printf("Hostname set to %s\n", name );
  302.             }
  303.         } else {
  304.             if(Hostname != NULLCHAR)
  305.                 free(Hostname);
  306.             Hostname = strdup(argv[1]);
  307.         }
  308.     }
  309.     return 0;
  310. }
  311. int
  312. dolog(argc,argv,p)
  313. int argc;
  314. char *argv[];
  315. void *p;
  316. {
  317.     static char *logname;
  318.     char tbuf[32];
  319.  
  320.     if(argc < 2){
  321.         if(Logfp)
  322.             printf("Logging to %s\n",logname);
  323.         else
  324.             printf("Logging off\n");
  325.         return 0;
  326.     }
  327.     if(Logfp){
  328.         log(NULLTCB,"NOS log closed");
  329.         fclose(Logfp);
  330.         Logfp = NULLFILE;
  331.         free(logname);
  332.         logname = NULLCHAR;
  333.     }
  334.     if(strcmp(argv[1],"stop") != 0){
  335.         logname = strdup(argv[1]);
  336.         Logfp = fopen(logname,APPEND_TEXT);
  337.         strcpy(tbuf,ctime(&StartTime));
  338.         rip(tbuf);
  339.         log(NULLTCB,"NOS was started at %s", tbuf);
  340. #ifdef MSDOS
  341.         log(NULLTCB,"NOS load information: CS=0x%04x DS=0x%04x", _CS, _DS);
  342. #endif
  343.     }
  344.     return 0;
  345. }
  346.  
  347. /* Attach an interface
  348.  * Syntax: attach <hw type> <I/O address> <vector> <mode> <label> <bufsize> [<speed>]
  349.  */
  350. int
  351. doattach(argc,argv,p)
  352. int argc;
  353. char *argv[];
  354. void *p;
  355. {
  356.     return subcmd(Attab,argc,argv,p);
  357. }
  358. /* Manipulate I/O device parameters */
  359. int
  360. doparam(argc,argv,p)
  361. int argc;
  362. char *argv[];
  363. void *p;
  364. {
  365.     register struct iface *ifp;
  366.     int param,set;
  367.     int32 val;
  368.  
  369.     if((ifp = if_lookup(argv[1])) == NULLIF){
  370.         printf("Interface \"%s\" unknown\n",argv[1]);
  371.         return 1;
  372.     }
  373.     if(ifp->ioctl == NULL){
  374.         printf("Not supported\n");
  375.         return 1;
  376.     }
  377.     if(argc < 3){
  378.         for(param=1;param<=16;param++){
  379.             val = (*ifp->ioctl)(ifp,param,FALSE,0L);
  380.             if(val != -1)
  381.                 printf("%s: %ld\n",parmname(param),val);
  382.         }
  383.         return 0;
  384.     }
  385.     param = devparam(argv[2]);
  386.     if(param == -1){
  387.         printf("Unknown parameter %s\n",argv[2]);
  388.         return 1;
  389.     }
  390.     if(argc < 4){
  391.         set = FALSE;
  392.         val = 0L;
  393.     } else {
  394.         set = TRUE;
  395.         val = atol(argv[3]);
  396.     }
  397.     val = (*ifp->ioctl)(ifp,param,set,val);
  398.     if(val == -1){
  399.         printf("Parameter %s not supported\n",argv[2]);
  400.     } else {
  401.         printf("%s: %ld\n",parmname(param),val);
  402.     }
  403.     return 0;
  404. }
  405.  
  406. /* Log messages of the form
  407.  * Tue Jan 31 00:00:00 1987 44.64.0.7:1003 open FTP
  408.  */
  409. /*VARARGS2*/
  410. void
  411. log(tcb,fmt,arg1,arg2,arg3,arg4)
  412. struct tcb *tcb;
  413. char *fmt;
  414. int32 arg1,arg2,arg3,arg4;
  415. {
  416.     char *cp;
  417.  
  418.     if(Logfp == NULLFILE)
  419.         return;
  420.     cp = ctime((long *) &Secclock);
  421.     rip(cp);
  422.     if (tcb)
  423.     fprintf(Logfp,"%s %s - ",cp,pinet_tcp(&tcb->conn.remote));
  424.     else
  425.     fprintf(Logfp,"%s - ",cp);
  426.     fprintf(Logfp,fmt,arg1,arg2,arg3,arg4);
  427.     fprintf(Logfp,"\n");
  428.     fflush(Logfp);
  429. #if     (defined(MSDOS) || defined(ATARI_ST))
  430.     /* MS-DOS doesn't really flush files until they're closed */
  431.     fd = fileno(Logfp);
  432.     if((fd = dup(fd)) != -1)
  433.         close(fd);
  434. #endif
  435. }
  436.  
  437. /* Display or set IP interface control flags */
  438. int
  439. domode(argc,argv,p)
  440. int argc;
  441. char *argv[];
  442. void *p;
  443. {
  444.     register struct iface *ifp;
  445.  
  446.     if((ifp = if_lookup(argv[1])) == NULLIF){
  447.         printf("Interface \"%s\" unknown\n",argv[1]);
  448.         return 1;
  449.     }
  450.     if(argc < 3){
  451.         printf("%s: %s\n",ifp->name,
  452.          (ifp->flags & CONNECT_MODE) ? "VC mode" : "Datagram mode");
  453.         return 0;
  454.     }
  455.     switch(argv[2][0]){
  456.     case 'v':
  457.     case 'c':
  458.     case 'V':
  459.     case 'C':
  460.         ifp->flags = CONNECT_MODE;
  461.         break;
  462.     case 'd':
  463.     case 'D':
  464.         ifp->flags = DATAGRAM_MODE;
  465.         break;
  466.     default:
  467.         printf("Usage: %s [vc | datagram]\n",argv[0]);
  468.         return 1;
  469.     }
  470.     return 0;
  471. }
  472.  
  473. #ifndef MSDOS
  474. int
  475. doescape(argc,argv,p)
  476. int argc;
  477. char *argv[];
  478. void *p;
  479. {
  480.     if(argc < 2)
  481.         printf("0x%x\n",Escape);
  482.     else
  483.         Escape = *argv[1];
  484.     return 0;
  485. }
  486. #endif  /* MSDOS */
  487. /* Generate system command packet. Synopsis:
  488.  * remote [-p port#] [-k key] [-a hostname] <hostname> reset|exit|kickme
  489.  */
  490. int
  491. doremote(argc,argv,p)
  492. int argc;
  493. char *argv[];
  494. void *p;
  495. {
  496.     struct socket fsock,lsock;
  497.     struct mbuf *bp;
  498.     int c;
  499.     int16 port,len;
  500.     char *key = NULLCHAR;
  501.     int klen;
  502.     int32 addr = 0;
  503.     char *cmd,*host;
  504.  
  505.     port = IPPORT_REMOTE;   /* Set default */
  506.     optind = 1;             /* reinit getopt() */
  507.     while((c = getopt(argc,argv,"a:p:k:s:")) != EOF){
  508.         switch(c){
  509.         case 'a':
  510.             addr = resolve(optarg);
  511.             break;
  512.         case 'p':
  513.             port = atoi(optarg);
  514.             break;
  515.         case 'k':
  516.             key = optarg;
  517.             klen = strlen(key);
  518.             break;
  519.         case 's':
  520.             Rempass = strdup(optarg);
  521.             return 0;       /* Only set local password */
  522.         }
  523.     }
  524.     if(optind > argc - 2){
  525.         printf("Insufficient args\n");
  526.         return -1;
  527.     }
  528.     host = argv[optind++];
  529.     cmd = argv[optind];
  530.  
  531.     if (!(fsock.address = resolve(host))) {
  532.         printf("Host %s unknown\n",host);
  533.         return 1;
  534.     }
  535.     lsock.address = INADDR_ANY;
  536.     lsock.port = fsock.port = port;
  537.  
  538.     len = 1;
  539.     /* Did the user include a password or kickme target? */
  540.     if(addr != 0)
  541.         len += sizeof(int32);
  542.  
  543.     if(key != NULLCHAR)
  544.         len += klen;
  545.  
  546.     bp = alloc_mbuf(len);
  547.     bp->cnt = 1;
  548.  
  549.     switch(cmd[0]){
  550.     case 'r':
  551.         bp->data[0] = SYS_RESET;
  552.         if(key != NULLCHAR) {
  553.             strncpy(&bp->data[1],key,klen);
  554.             bp->cnt += klen;
  555.         }
  556.         break;
  557.     case 'e':
  558.         bp->data[0] = SYS_EXIT;
  559.         if(key != NULLCHAR) {
  560.             strncpy(&bp->data[1],key,klen);
  561.             bp->cnt += klen;
  562.         }
  563.         break;
  564.     case 'k':
  565.         bp->data[0] = KICK_ME;
  566.         if(addr != 0) {
  567.             put32(&bp->data[1],addr);
  568.             bp->cnt += sizeof(int32);
  569.         }
  570.         break;
  571.     default:
  572.         printf("Unknown command %s\n",cmd);
  573.         free_p(bp);
  574.         return 1;
  575.     }
  576.     send_udp(&lsock,&fsock,0,0,bp,0,0,0);
  577.     return 0;
  578. }
  579. /* No-op command */
  580. int
  581. donothing(argc,argv,p)
  582. int argc;
  583. char *argv[];
  584. void *p;
  585. {
  586.     return 0;
  587. }
  588.  
  589. /*---------------------------------------------------------------------------*/
  590.  
  591. int  dosource(argc, argv, p)
  592. int  argc;
  593. char  *argv[];
  594. void *p;
  595. {
  596.  
  597.   FILE * fp;
  598.   char  linebuf[BUFSIZ];
  599.  
  600.   if (!(fp = fopen(argv[1], "r"))) {
  601.     printf("cannot open %s\n", argv[1]);
  602.     return 1;
  603.   }
  604.   while (fgets(linebuf, BUFSIZ, fp))
  605.     cmdparse(Cmds, linebuf, NULL);
  606.   fclose(fp);
  607.   Mode = CMD_MODE;
  608.   cooked();
  609.   return 0;
  610. }
  611.  
  612.